// 智谱API配置
const ZHIPU_API_CONFIG = {
    baseURL: 'https://open.bigmodel.cn/api/paas/v4/chat/completions',
    apiKey: '', // 需要用户配置
    model: 'glm-4-flash'
};

// 本地存储键名
const STORAGE_KEYS = {
    API_KEY: 'zhipu_api_key',
    EDITOR_CONTENT: 'editor_content'
};

// 预置提示词
const PROMPTS = {
    polish: `你是一个专业的商务写作专家。请对用户提供的内容进行润色优化，要求：
1. 保持原意不变，提升表达的专业性和说服力
2. 优化语言结构，使表达更加清晰有力
3. 适合商务路演场景，体现专业性
4. 保持内容的逻辑性和连贯性
5. 直接返回优化后的内容，使用纯文本格式，不要使用任何Markdown格式（如**粗体**、*斜体*等）
6. 不要添加额外说明

用户内容：`,

    expand: `你是一个专业的PPT内容策划专家。请参考以下案例格式，对用户提供的内容进行扩写：

【参考案例格式】：
项目名称：PPT内容构思辅助工具
核心价值：通过AI技术帮助技术人员快速构思和优化路演内容，让非专业人士也能写出专业的PPT文案。
解决问题：技术人员在准备路演时，往往技术能力强但文案表达能力不足，难以将技术优势转化为有说服力的商业表达。
目标用户：参加黑客松、创业比赛、技术分享的开发者和技术团队。
市场机会：随着技术创业热潮，每年有数万场技术路演需要专业的内容支持。

【扩写要求】：
1. 严格按照上述案例的格式和结构进行扩写
2. 保持简洁有力的表达风格，每个要点控制在1-2句话
3. 突出项目的核心价值和商业价值
4. 适合PPT展示的简洁风格，避免冗长描述
5. 使用纯文本格式输出，不要使用任何Markdown格式（如**粗体**、*斜体*等）
6. 直接返回扩写后的内容，不要添加额外说明

用户内容：`,

    summarize: `你是一个专业的内容总结专家。请对用户提供的内容进行总结提炼，要求：
1. 提取核心要点和关键信息
2. 保持逻辑结构清晰
3. 适合PPT展示的简洁风格
4. 突出重点和亮点
5. 保持专业性和说服力
6. 使用纯文本格式输出，不要使用任何Markdown格式（如**粗体**、*斜体*等）
7. 直接返回总结后的内容，不要添加额外说明

用户内容：`
};

// DOM元素
const elements = {
    // 编辑器相关
    contentEditor: document.getElementById('contentEditor'),
    clearBtn: document.getElementById('clearBtn'),
    copyBtn: document.getElementById('copyBtn'),
    
    // 参考案例相关
    examplesSidebar: document.getElementById('examplesSidebar'),
    toggleExamples: document.getElementById('toggleExamples'),
    expandExamples: document.getElementById('expandExamples'),
    
    // API配置相关
    toggleConfig: document.getElementById('toggleConfig'),
    configPanel: document.getElementById('configPanel'),
    apiKeyInput: document.getElementById('apiKeyInput'),
    saveApiKey: document.getElementById('saveApiKey'),
    configStatus: document.getElementById('configStatus'),
    
    // AI功能相关
    polishBtn: document.getElementById('polishBtn'),
    expandBtn: document.getElementById('expandBtn'),
    summarizeBtn: document.getElementById('summarizeBtn'),
    resultContent: document.getElementById('resultContent'),
    copyResultBtn: document.getElementById('copyResultBtn'),
    
    // 加载状态
    loadingModal: document.getElementById('loadingModal'),
    
    // AI对话相关
    chatMessages: document.getElementById('chatMessages'),
    chatInput: document.getElementById('chatInput'),
    sendChatBtn: document.getElementById('sendChatBtn'),
    exportChatBtn: document.getElementById('exportChatBtn'),
    clearChatBtn: document.getElementById('clearChatBtn'),
    
    // AI功能区域隐藏/展开
    collapseAiSection: document.getElementById('collapseAiSection'),
    expandAiSection: document.getElementById('expandAiSection'),
    aiSection: document.querySelector('.ai-section'),
    chatSection: document.querySelector('.chat-section')
};

// 工具函数
class Utils {
    // 获取选中的文本
    static getSelectedText() {
        const editor = elements.contentEditor;
        const start = editor.selectionStart;
        const end = editor.selectionEnd;
        
        if (start === end) {
            // 如果没有选中文本，返回全部内容
            return editor.value.trim();
        }
        
        return editor.value.substring(start, end).trim();
    }

    // 显示加载状态
    static showLoading() {
        elements.loadingModal.style.display = 'flex';
        // 禁用所有AI按钮
        elements.polishBtn.disabled = true;
        elements.expandBtn.disabled = true;
        elements.summarizeBtn.disabled = true;
    }

    // 隐藏加载状态
    static hideLoading() {
        elements.loadingModal.style.display = 'none';
        // 启用所有AI按钮
        elements.polishBtn.disabled = false;
        elements.expandBtn.disabled = false;
        elements.summarizeBtn.disabled = false;
    }

    // 显示结果
    static showResult(content) {
        elements.resultContent.innerHTML = `
            <div class="ai-response">${content}</div>
        `;
        elements.copyResultBtn.style.display = 'block';
    }

    // 显示错误信息
    static showError(message) {
        elements.resultContent.innerHTML = `
            <div class="error-message" style="color: #ef4444; padding: 16px; background: #fef2f2; border: 1px solid #fecaca; border-radius: 8px;">
                <strong>处理失败：</strong>${message}
            </div>
        `;
        elements.copyResultBtn.style.display = 'none';
    }

    // 复制文本到剪贴板
    static async copyToClipboard(text) {
        try {
            await navigator.clipboard.writeText(text);
            this.showToast('已复制到剪贴板');
        } catch (err) {
            // 降级方案
            const textArea = document.createElement('textarea');
            textArea.value = text;
            document.body.appendChild(textArea);
            textArea.select();
            document.execCommand('copy');
            document.body.removeChild(textArea);
            this.showToast('已复制到剪贴板');
        }
    }

    // 显示提示消息
    static showToast(message) {
        const toast = document.createElement('div');
        toast.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            background: #10b981;
            color: white;
            padding: 12px 20px;
            border-radius: 8px;
            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
            z-index: 1001;
            font-size: 14px;
            animation: slideIn 0.3s ease;
        `;
        toast.textContent = message;
        
        // 添加动画样式
        const style = document.createElement('style');
        style.textContent = `
            @keyframes slideIn {
                from { transform: translateX(100%); opacity: 0; }
                to { transform: translateX(0); opacity: 1; }
            }
        `;
        document.head.appendChild(style);
        
        document.body.appendChild(toast);
        
        setTimeout(() => {
            toast.remove();
            style.remove();
        }, 3000);
    }
    
    // 本地存储相关
    static saveToStorage(key, value) {
        try {
            localStorage.setItem(key, value);
            return true;
        } catch (err) {
            console.error('保存到本地存储失败:', err);
            return false;
        }
    }
    
    static getFromStorage(key) {
        try {
            return localStorage.getItem(key);
        } catch (err) {
            console.error('从本地存储读取失败:', err);
            return null;
        }
    }
    
    // 检查API密钥是否已配置
    static isApiKeyConfigured() {
        const apiKey = this.getFromStorage(STORAGE_KEYS.API_KEY);
        return apiKey && apiKey.trim().length > 0;
    }
    
    // 更新配置状态显示
    static updateConfigStatus() {
        const statusElement = elements.configStatus;
        if (this.isApiKeyConfigured()) {
            statusElement.innerHTML = '<span class="configured">已配置</span>';
        } else {
            statusElement.innerHTML = '<span>未配置</span>';
        }
    }
}

// AI API调用类
class AIService {
    static async callAPI(prompt, content) {
        // 检查API密钥
        const apiKey = Utils.getFromStorage(STORAGE_KEYS.API_KEY);
        if (!apiKey || apiKey.trim().length === 0) {
            throw new Error('请先配置API密钥');
        }

        try {
            const response = await fetch(ZHIPU_API_CONFIG.baseURL, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${apiKey}`
                },
                body: JSON.stringify({
                    model: ZHIPU_API_CONFIG.model,
                    messages: [
                        {
                            role: 'user',
                            content: `${prompt}\n\n需要处理的内容：\n${content}`
                        }
                    ],
                    temperature: 0.7,
                    max_tokens: 2000
                })
            });

            if (!response.ok) {
                if (response.status === 401) {
                    throw new Error('API密钥无效，请检查配置');
                }
                throw new Error(`API请求失败: ${response.status}`);
            }

            const data = await response.json();
            return data.choices[0].message.content;
        } catch (error) {
            console.error('API调用错误:', error);
            if (error.message.includes('API密钥')) {
                throw error;
            }
            throw new Error('AI服务暂时不可用，请稍后重试');
        }
    }

    static async processContent(type, content) {
        if (!content) {
            throw new Error('请先选择要处理的内容');
        }

        const prompt = PROMPTS[type];
        if (!prompt) {
            throw new Error('未知的处理类型');
        }

        return await this.callAPI(prompt, content);
    }
}

// 事件处理类
class EventHandlers {
    static bindEvents() {
        // 参考案例展开收起
        elements.toggleExamples.addEventListener('click', EventHandlers.handleToggleExamples);
        elements.expandExamples.addEventListener('click', EventHandlers.handleExpandExamples);
        
        // API配置相关
        elements.toggleConfig.addEventListener('click', EventHandlers.handleToggleConfig);
        elements.saveApiKey.addEventListener('click', EventHandlers.handleSaveApiKey);
        elements.apiKeyInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                EventHandlers.handleSaveApiKey();
            }
        });
        
        // AI功能按钮事件
        elements.polishBtn.addEventListener('click', () => EventHandlers.handleAIFunction('polish'));
        elements.expandBtn.addEventListener('click', () => EventHandlers.handleAIFunction('expand'));
        elements.summarizeBtn.addEventListener('click', () => EventHandlers.handleAIFunction('summarize'));
        
        // 复制按钮事件
        elements.copyResultBtn.addEventListener('click', EventHandlers.handleCopyResult);
        elements.copyBtn.addEventListener('click', EventHandlers.handleCopyAll);
        
        // 清空按钮事件
        elements.clearBtn.addEventListener('click', EventHandlers.handleClearEditor);
        
        // 编辑器内容自动保存
        elements.contentEditor.addEventListener('input', EventHandlers.handleContentChange);
        
        // AI对话事件
        elements.sendChatBtn.addEventListener('click', EventHandlers.handleSendChat);
        elements.chatInput.addEventListener('keydown', EventHandlers.handleChatKeydown);
        elements.exportChatBtn.addEventListener('click', EventHandlers.handleExportChat);
        elements.clearChatBtn.addEventListener('click', EventHandlers.handleClearChat);
        
        // AI功能区域隐藏/展开事件
        elements.collapseAiSection.addEventListener('click', EventHandlers.handleCollapseAiSection);
        elements.expandAiSection.addEventListener('click', EventHandlers.handleExpandAiSection);
    }
    
    static handleToggleExamples() {
        const sidebar = elements.examplesSidebar;
        const toggleBtn = elements.toggleExamples;
        const expandBtn = elements.expandExamples;
        
        if (sidebar.classList.contains('collapsed')) {
            sidebar.classList.remove('collapsed');
            toggleBtn.textContent = '收起';
            expandBtn.style.display = 'none';
        } else {
            sidebar.classList.add('collapsed');
            toggleBtn.textContent = '展开';
            expandBtn.style.display = 'flex';
        }
    }
    
    static handleExpandExamples() {
        const sidebar = elements.examplesSidebar;
        const toggleBtn = elements.toggleExamples;
        const expandBtn = elements.expandExamples;
        
        sidebar.classList.remove('collapsed');
        toggleBtn.textContent = '收起';
        expandBtn.style.display = 'none';
    }
    
    static handleToggleConfig() {
        const panel = elements.configPanel;
        const button = elements.toggleConfig;
        
        if (panel.style.display === 'none') {
            panel.style.display = 'block';
            button.textContent = '收起';
        } else {
            panel.style.display = 'none';
            button.textContent = '设置';
        }
    }
    
    static handleSaveApiKey() {
        const apiKey = elements.apiKeyInput.value.trim();
        if (!apiKey) {
            Utils.showToast('请输入API密钥');
            return;
        }
        
        if (Utils.saveToStorage(STORAGE_KEYS.API_KEY, apiKey)) {
            Utils.showToast('API密钥已保存');
            Utils.updateConfigStatus();
            elements.configPanel.style.display = 'none';
            elements.toggleConfig.textContent = '设置';
        } else {
            Utils.showToast('保存失败，请重试');
        }
    }
    
    static handleContentChange() {
        const content = elements.contentEditor.value;
        Utils.saveToStorage(STORAGE_KEYS.EDITOR_CONTENT, content);
    }

    static async handleAIFunction(type) {
        try {
            const selectedText = Utils.getSelectedText();
            
            if (!selectedText) {
                Utils.showError('请先输入内容或选择要处理的文本');
                return;
            }

            Utils.showLoading();
            
            const result = await AIService.processContent(type, selectedText);
            
            Utils.showResult(result);
            
        } catch (error) {
            console.error('AI处理错误:', error);
            Utils.showError(error.message);
        } finally {
            Utils.hideLoading();
        }
    }

    static handleCopyResult() {
        const resultElement = elements.resultContent.querySelector('.ai-response');
        if (resultElement) {
            Utils.copyToClipboard(resultElement.textContent);
        }
    }

    static handleClearEditor() {
        if (elements.contentEditor.value.trim() && confirm('确定要清空编辑器内容吗？')) {
            elements.contentEditor.value = '';
            Utils.saveToStorage(STORAGE_KEYS.EDITOR_CONTENT, '');
            elements.resultContent.innerHTML = `
                <div class="placeholder">
                    <p>选择编辑器中的文本，然后点击上方AI功能按钮</p>
                    <p>AI将为你提供专业的内容建议</p>
                </div>
            `;
            elements.copyResultBtn.style.display = 'none';
            elements.contentEditor.focus();
        }
    }

    static handleCopyAll() {
        if (elements.contentEditor.value.trim()) {
            Utils.copyToClipboard(elements.contentEditor.value);
        } else {
            Utils.showToast('编辑器内容为空');
        }
    }
    
    // AI对话相关事件处理
    static async handleSendChat() {
        const input = elements.chatInput;
        const message = input.value.trim();
        
        if (!message) {
            Utils.showToast('请输入消息');
            return;
        }
        
        // 添加用户消息到聊天记录
        EventHandlers.addChatMessage('user', message);
        input.value = '';
        
        try {
            // 显示AI正在思考
            const thinkingId = EventHandlers.addChatMessage('assistant', '正在思考...');
            
            // 调用AI API
            const response = await AIService.callAPI('用户有问题需要你帮忙', message);
            
            // 移除思考消息，添加AI回复
            EventHandlers.removeChatMessage(thinkingId);
            EventHandlers.addChatMessage('assistant', response);
            
        } catch (error) {
            console.error('AI对话错误:', error);
            EventHandlers.removeChatMessage(thinkingId);
            EventHandlers.addChatMessage('assistant', `抱歉，AI服务暂时不可用：${error.message}`);
        }
    }
    
    static handleChatKeydown(e) {
        if (e.key === 'Enter' && !e.shiftKey) {
            e.preventDefault();
            EventHandlers.handleSendChat();
        }
    }
    
    static handleExportChat() {
        const messages = elements.chatMessages.querySelectorAll('.chat-message');
        if (messages.length === 0) {
            Utils.showToast('暂无对话记录');
            return;
        }
        
        let exportText = 'PPT助手对话记录\n\n';
        messages.forEach(msg => {
            const role = msg.classList.contains('user-message') ? '用户' : 'AI助手';
            const content = msg.querySelector('.message-content').textContent;
            exportText += `${role}：${content}\n\n`;
        });
        
        Utils.copyToClipboard(exportText);
        Utils.showToast('对话记录已复制到剪贴板');
    }
    
    static handleClearChat() {
        if (elements.chatMessages.children.length === 0) {
            Utils.showToast('对话记录已为空');
            return;
        }
        
        if (confirm('确定要清空所有对话记录吗？')) {
            elements.chatMessages.innerHTML = '';
            Utils.showToast('对话记录已清空');
        }
    }
    
    // AI功能区域隐藏/展开事件处理
    static handleCollapseAiSection() {
        elements.aiSection.style.display = 'none';
        elements.chatSection.style.display = 'none';
        elements.collapseAiSection.style.display = 'none';
        elements.expandAiSection.style.display = 'block';
    }
    
    static handleExpandAiSection() {
        elements.aiSection.style.display = 'block';
        elements.chatSection.style.display = 'block';
        elements.collapseAiSection.style.display = 'block';
        elements.expandAiSection.style.display = 'none';
    }
    
    // 聊天消息管理
    static addChatMessage(role, content) {
        const messageId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
        const messageDiv = document.createElement('div');
        messageDiv.className = `chat-message ${role}-message`;
        messageDiv.id = messageId;
        
        messageDiv.innerHTML = `
            <div class="message-content">${content}</div>
            <div class="message-time">${new Date().toLocaleTimeString()}</div>
        `;
        
        elements.chatMessages.appendChild(messageDiv);
        elements.chatMessages.scrollTop = elements.chatMessages.scrollHeight;
        
        return messageId;
    }
    
    static removeChatMessage(messageId) {
        const message = document.getElementById(messageId);
        if (message) {
            message.remove();
        }
    }
}

// 应用初始化类
class App {
    static init() {
        this.bindEvents();
        this.loadSavedContent();
        this.updateConfigStatus();
    }

    static bindEvents() {
        EventHandlers.bindEvents();
        
        // 键盘快捷键
        document.addEventListener('keydown', App.handleKeyboard);
    }

    static handleKeyboard(e) {
        // Ctrl+S 保存
        if (e.ctrlKey && e.key === 's') {
            e.preventDefault();
            Utils.showToast('内容已自动保存');
        }
        
        // Ctrl+A 全选编辑器内容
        if (e.ctrlKey && e.key === 'a' && document.activeElement === elements.contentEditor) {
            e.preventDefault();
            elements.contentEditor.select();
        }
    }

    static loadSavedContent() {
        // 加载保存的内容
        const savedContent = Utils.getFromStorage(STORAGE_KEYS.EDITOR_CONTENT);
        if (savedContent) {
            elements.contentEditor.value = savedContent;
        }
        
        // 加载保存的API密钥
        const savedApiKey = Utils.getFromStorage(STORAGE_KEYS.API_KEY);
        if (savedApiKey) {
            elements.apiKeyInput.value = savedApiKey;
        }
    }
    
    static updateConfigStatus() {
        Utils.updateConfigStatus();
    }
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    App.init();
    
    // 给编辑器焦点
    elements.contentEditor.focus();
    
    console.log('PPT内容构思辅助工具已加载完成');
    console.log('请配置智谱API密钥以使用AI功能');
});